```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Netty 架构解析 - 高性能网络通信框架</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css">
    <link rel="stylesheet" href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        body {
            font-family: 'Noto Sans SC', Tahoma, Arial, Roboto, "Droid Sans", "Helvetica Neue", "Droid Sans Fallback", "Heiti SC", "Hiragino Sans GB", Simsun, sans-serif;
            color: #333;
            line-height: 1.6;
            background-color: #f8fafc;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 700;
            color: #1e293b;
        }
        .hero-gradient {
            background: linear-gradient(135deg, #4f46e5 0%, #7c3aed 100%);
        }
        .code-block {
            background-color: #1e293b;
            border-left: 4px solid #4f46e5;
        }
        .hover-scale {
            transition: transform 0.3s ease, box-shadow 0.3s ease;
        }
        .hover-scale:hover {
            transform: translateY(-5px);
            box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
        }
    </style>
</head>
<body class="antialiased">
    <!-- Hero Section -->
    <section class="hero-gradient text-white py-20 md:py-32 px-4 md:px-0">
        <div class="container mx-auto max-w-6xl text-center">
            <h1 class="text-4xl md:text-6xl font-bold mb-6 animate-fade-in">Netty 架构解析</h1>
            <p class="text-xl md:text-2xl max-w-3xl mx-auto opacity-90 mb-10">高性能网络通信框架的设计精髓</p>
            <div class="flex justify-center space-x-4">
                <a href="#architecture" class="bg-white text-indigo-600 px-6 py-3 rounded-lg font-medium hover:bg-opacity-90 transition duration-300 shadow-lg">
                    <i class="fas fa-layer-group mr-2"></i>架构解析
                </a>
                <a href="#features" class="bg-indigo-800 text-white px-6 py-3 rounded-lg font-medium hover:bg-opacity-90 transition duration-300 shadow-lg">
                    <i class="fas fa-star mr-2"></i>核心特性
                </a>
            </div>
        </div>
    </section>

    <!-- Main Content -->
    <div class="container mx-auto max-w-6xl px-4 py-16">
        <!-- Introduction -->
        <section class="mb-20">
            <div class="bg-white rounded-xl shadow-md p-8 hover-scale">
                <p class="text-lg leading-relaxed text-gray-700">
                    Netty 是一个高性能的网络通信框架，其架构设计精巧且灵活，旨在处理高并发和大规模的网络通信场景。它基于事件驱动模型，提供了高度模块化的组件，能够轻松构建各种网络应用，从简单的服务器到复杂的分布式系统。
                </p>
            </div>
        </section>

        <!-- Architecture Overview -->
        <section id="architecture" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">1. Netty的整体架构</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8 mb-10">
                <div>
                    <p class="text-gray-700 mb-6">
                        Netty 的整体架构设计遵循了"事件驱动"的模型，并使用了多层次的模块划分来实现高效的网络通信。Netty 的核心部分主要包括以下几个关键模块：
                    </p>
                    <ul class="space-y-3">
                        <li class="flex items-start">
                            <span class="text-indigo-600 mr-2 mt-1"><i class="fas fa-project-diagram"></i></span>
                            <span><strong>NIO 模块 (Channel)</strong> - 网络连接的抽象表示</span>
                        </li>
                        <li class="flex items-start">
                            <span class="text-indigo-600 mr-2 mt-1"><i class="fas fa-clock"></i></span>
                            <span><strong>线程模型 (EventLoop)</strong> - 事件循环处理核心</span>
                        </li>
                        <li class="flex items-start">
                            <span class="text-indigo-600 mr-2 mt-1"><i class="fas fa-code"></i></span>
                            <span><strong>数据编解码模块 (ChannelHandler)</strong> - 数据处理流水线</span>
                        </li>
                        <li class="flex items-start">
                            <span class="text-indigo-600 mr-2 mt-1"><i class="fas fa-memory"></i></span>
                            <span><strong>内存管理模块 (ByteBuf)</strong> - 高效内存分配</span>
                        </li>
                        <li class="flex items-start">
                            <span class="text-indigo-600 mr-2 mt-1"><i class="fas fa-network-wired"></i></span>
                            <span><strong>协议实现模块</strong> - 支持多种网络协议</span>
                        </li>
                    </ul>
                </div>
                <div class="bg-gray-50 rounded-xl p-6">
                    <div class="mermaid">
                        graph TD
                            A[Client] --> B[Channel]
                            B --> C[EventLoop]
                            C --> D[ChannelPipeline]
                            D --> E[Inbound Handlers]
                            D --> F[Outbound Handlers]
                            E --> G[ByteBuf]
                            F --> G
                            G --> H[Network]
                            C --> I[Thread Pool]
                            style A fill:#f5f5f5,stroke:#4f46e5
                            style B fill:#e0e7ff,stroke:#4f46e5
                            style C fill:#c7d2fe,stroke:#4f46e5
                            style D fill:#a5b4fc,stroke:#4f46e5
                            style E fill:#818cf8,stroke:#4f46e5
                            style F fill:#6366f1,stroke:#4f46e5
                            style G fill:#4f46e5,stroke:#4f46e5,color:white
                            style H fill:#f5f5f5,stroke:#4f46e5
                            style I fill:#c7d2fe,stroke:#4f46e5
                    </div>
                </div>
            </div>
        </section>

        <!-- Boss-Worker Model -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">2. 主从模式 (Boss-Worker)</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        Netty 的网络通信遵循了 Boss-Worker 模式，以提高并发处理能力。这种模式将连接接受和IO处理分离，实现更好的资源利用。
                    </p>
                    <div class="bg-indigo-50 rounded-lg p-6 mb-6">
                        <h4 class="font-bold text-indigo-800 mb-3"><i class="fas fa-user-tie mr-2"></i>Boss线程</h4>
                        <p class="text-gray-700">
                            负责监听和接受客户端的连接请求。Boss 线程不做数据的读写，只负责分配连接。
                        </p>
                    </div>
                    <div class="bg-purple-50 rounded-lg p-6">
                        <h4 class="font-bold text-purple-800 mb-3"><i class="fas fa-users mr-2"></i>Worker线程</h4>
                        <p class="text-gray-700">
                            负责处理已经建立的连接的数据读写。每个连接分配一个 Worker 线程，处理对应的 IO 操作。
                        </p>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">// Boss 线程组
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
// Worker 线程组
EventLoopGroup workerGroup = new NioEventLoopGroup();</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li>Boss 线程接受客户端连接</li>
                            <li>将连接交给 Worker 线程来处理后续的读写操作</li>
                            <li>每个 Worker 线程处理多个客户端连接的 IO 任务</li>
                        </ol>
                    </div>
                </div>
            </div>
        </section>

        <!-- EventLoop Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">3. EventLoop 和 EventLoopGroup</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code> 是 Netty 中处理事件的核心组件，负责处理 I/O 操作及任务调度。每个线程拥有一个 <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code>，而 <code class="bg-gray-100 px-2 py-1 rounded">EventLoopGroup</code> 则管理多个 <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code>。
                    </p>
                    <div class="bg-white rounded-xl shadow-sm p-6 mb-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-redo mr-2 text-indigo-600"></i>EventLoop
                        </h4>
                        <p class="text-gray-700">
                            一个线程（通常是 Worker 线程）会有一个对应的 <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code> 来处理所有与该线程相关的事件。
                        </p>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-object-group mr-2 text-indigo-600"></i>EventLoopGroup
                        </h4>
                        <p class="text-gray-700">
                            负责管理多个 <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code>，并协调线程之间的任务调度。
                        </p>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">public interface EventLoop extends EventExecutor {
    void execute(Runnable command);
    boolean inEventLoop(Thread thread);
}</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li>当 Netty 启动时，创建一个 <code class="bg-gray-100 px-2 py-1 rounded">EventLoopGroup</code></li>
                            <li>将多个 <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code> 绑定到不同的线程</li>
                            <li>每个线程的 <code class="bg-gray-100 px-2 py-1 rounded">EventLoop</code> 负责监听和处理 I/O 事件</li>
                        </ol>
                    </div>
                </div>
            </div>
        </section>

        <!-- Channel Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">4. Channel 和 ChannelPipeline</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        Netty 中的 <code class="bg-gray-100 px-2 py-1 rounded">Channel</code> 是连接的抽象，负责数据的传输。每个 <code class="bg-gray-100 px-2 py-1 rounded">Channel</code> 都有一个 <code class="bg-gray-100 px-2 py-1 rounded">ChannelPipeline</code>，用于链式处理 I/O 操作。
                    </p>
                    <div class="bg-white rounded-xl shadow-sm p-6 mb-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-plug mr-2 text-indigo-600"></i>Channel
                        </h4>
                        <p class="text-gray-700">
                            用于代表一个网络连接。所有数据的读写操作都通过 <code class="bg-gray-100 px-2 py-1 rounded">Channel</code> 来完成。
                        </p>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-random mr-2 text-indigo-600"></i>ChannelPipeline
                        </h4>
                        <p class="text-gray-700">
                            通过 <code class="bg-gray-100 px-2 py-1 rounded">ChannelPipeline</code> 管理一系列的 <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code>，每个 <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code> 处理不同类型的事件。
                        </p>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">public interface Channel {
    ChannelPipeline pipeline();
    void writeAndFlush(Object msg);
}</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li>客户端连接建立后，Netty 为每个 <code class="bg-gray-100 px-2 py-1 rounded">Channel</code> 创建对应的 <code class="bg-gray-100 px-2 py-1 rounded">ChannelPipeline</code></li>
                            <li>数据的读写操作会依次通过 <code class="bg-gray-100 px-2 py-1 rounded">ChannelPipeline</code> 中的 <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code> 处理</li>
                        </ol>
                    </div>
                </div>
            </div>
        </section>

        <!-- ChannelHandler Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">5. ChannelHandler 和数据处理链</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code> 是 Netty 中处理数据的核心，主要分为两类：Inbound Handler 和 Outbound Handler。每个 <code class="bg-gray-100 px-2 py-1 rounded">ChannelPipeline</code> 由多个 <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code> 组成，通过链式调用处理不同的 I/O 事件。
                    </p>
                    <div class="bg-blue-50 rounded-lg p-6 mb-6">
                        <h4 class="font-bold text-blue-800 mb-3 flex items-center">
                            <i class="fas fa-sign-in-alt mr-2"></i>Inbound Handler
                        </h4>
                        <p class="text-gray-700">
                            用于处理从网络读取的数据，如解码器、业务逻辑处理器等。
                        </p>
                    </div>
                    <div class="bg-orange-50 rounded-lg p-6">
                        <h4 class="font-bold text-orange-800 mb-3 flex items-center">
                            <i class="fas fa-sign-out-alt mr-2"></i>Outbound Handler
                        </h4>
                        <p class="text-gray-700">
                            用于处理写入网络的数据，如编码器、压缩处理器等。
                        </p>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">public interface ChannelHandler {
    void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception;
    void channelReadComplete(ChannelHandlerContext ctx) throws Exception;
}</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li>客户端发送的数据通过 <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code> 进行解码和处理</li>
                            <li>处理完成后，数据可以通过 <code class="bg-gray-100 px-2 py-1 rounded">ChannelHandler</code> 传递给下一个 <code class="bg-gray-100 px-2 py-1 rounded">Handler</code></li>
                            <li>或者直接写入网络</li>
                        </ol>
                        <div class="mt-4 border-l-4 border-indigo-500 pl-4 italic text-gray-600">
                            <p>这种责任链模式使得数据处理逻辑可以灵活组合，易于扩展和维护</p>
                        </div>
                    </div>
                </div>
            </div>
        </section>

        <!-- ByteBuf Section -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">6. ByteBuf 和内存管理</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        <code class="bg-gray-100 px-2 py-1 rounded">ByteBuf</code> 是 Netty 中用于缓冲数据的类，它提供了更加高效的内存管理方式，避免了频繁的内存分配和释放带来的性能损耗。
                    </p>
                    <div class="bg-green-50 rounded-lg p-6 mb-6">
                        <h4 class="font-bold text-green-800 mb-3 flex items-center">
                            <i class="fas fa-layer-group mr-2"></i>Heap ByteBuf
                        </h4>
                        <p class="text-gray-700">
                            使用 JVM 堆内存，GC 管理，访问速度快但存在复制开销。
                        </p>
                    </div>
                    <div class="bg-teal-50 rounded-lg p-6">
                        <h4 class="font-bold text-teal-800 mb-3 flex items-center">
                            <i class="fas fa-bolt mr-2"></i>Direct ByteBuf
                        </h4>
                        <p class="text-gray-700">
                            使用操作系统的直接内存，避免了 JVM 堆与操作系统之间的拷贝，性能更高。
                        </p>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">PooledByteBufAllocator allocator = PooledByteBufAllocator.DEFAULT;
ByteBuf buf = allocator.directBuffer();</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li><code class="bg-gray-100 px-2 py-1 rounded">ByteBuf</code> 管理数据缓冲区</li>
                            <li>通过池化的方式来减少内存分配的开销</li>
                            <li>数据的读写操作通过 <code class="bg-gray-100 px-2 py-1 rounded">ByteBuf</code> 完成</li>
                            <li>Netty 使用内存池技术管理 <code class="bg-gray-100 px-2 py-1 rounded">ByteBuf</code> 对象，优化性能</li>
                        </ol>
                    </div>
                </div>
            </div>
        </section>

        <!-- Transport Model -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">7. 网络传输模型：NIO 和 Epoll</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        Netty 提供了多种传输方式，常用的有 NIO 和 Epoll（仅在 Linux 下支持），以满足不同场景下的性能需求。
                    </p>
                    <div class="bg-yellow-50 rounded-lg p-6 mb-6">
                        <h4 class="font-bold text-yellow-800 mb-3 flex items-center">
                            <i class="fab fa-java mr-2"></i>NIO
                        </h4>
                        <p class="text-gray-700">
                            基于 Java 的 <code class="bg-gray-100 px-2 py-1 rounded">Selector</code> 和 <code class="bg-gray-100 px-2 py-1 rounded">Channel</code> 实现的非阻塞 I/O，跨平台支持好。
                        </p>
                    </div>
                    <div class="bg-red-50 rounded-lg p-6">
                        <h4 class="font-bold text-red-800 mb-3 flex items-center">
                            <i class="fab fa-linux mr-2"></i>Epoll
                        </h4>
                        <p class="text-gray-700">
                            在 Linux 系统中，Netty 使用 Epoll 实现更高效的 I/O 多路复用，性能优于 NIO。
                        </p>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">ChannelFactory factory = new EpollEventLoopGroup();</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li>Netty 根据操作系统类型选择不同的传输模型</li>
                            <li>使用 <code class="bg-gray-100 px-2 py-1 rounded">Epoll</code> 或 <code class="bg-gray-100 px-2 py-1 rounded">NIO</code> 模型进行事件的多路复用</li>
                            <li>提高网络通信的并发能力</li>
                        </ol>
                    </div>
                </div>
            </div>
        </section>

        <!-- Event-Driven Model -->
        <section class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">8. 事件驱动模型与异步编程</h2>
            </div>
            
            <div class="grid md:grid-cols-2 gap-8">
                <div>
                    <p class="text-gray-700 mb-6">
                        Netty 的事件驱动模型使得其能够支持高并发的异步 I/O 操作。通过 <code class="bg-gray-100 px-2 py-1 rounded">Future</code> 和 <code class="bg-gray-100 px-2 py-1 rounded">Promise</code> 对象，Netty 可以高效地处理异步操作。
                    </p>
                    <div class="bg-indigo-50 rounded-xl p-6 hover-scale">
                        <h4 class="font-bold text-indigo-800 mb-3 flex items-center">
                            <i class="fas fa-bolt mr-2"></i>异步编程优势
                        </h4>
                        <ul class="space-y-2 text-gray-700">
                            <li class="flex items-start">
                                <span class="text-indigo-600 mr-2">✓</span>
                                <span>非阻塞IO，提高系统吞吐量</span>
                            </li>
                            <li class="flex items-start">
                                <span class="text-indigo-600 mr-2">✓</span>
                                <span>更高效的线程利用率</span>
                            </li>
                            <li class="flex items-start">
                                <span class="text-indigo-600 mr-2">✓</span>
                                <span>简化并发编程模型</span>
                            </li>
                            <li class="flex items-start">
                                <span class="text-indigo-600 mr-2">✓</span>
                                <span>更好的可扩展性</span>
                            </li>
                        </ul>
                    </div>
                </div>
                <div>
                    <div class="code-block rounded-lg p-6 mb-6">
                        <pre class="text-green-400 overflow-x-auto">
<code class="text-sm">ChannelFuture future = channel.writeAndFlush(msg);
future.addListener(future -> {
    if (future.isSuccess()) {
        System.out.println("Message sent successfully");
    } else {
        future.cause().printStackTrace();
    }
});</code>
                        </pre>
                    </div>
                    <div class="bg-white rounded-xl shadow-sm p-6">
                        <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                            <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                        </h4>
                        <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                            <li>异步操作返回一个 <code class="bg-gray-100 px-2 py-1 rounded">ChannelFuture</code>，表示操作是否成功</li>
                            <li>使用 <code class="bg-gray-100 px-2 py-1 rounded">addListener</code> 方法为 <code class="bg-gray-100 px-2 py-1 rounded">ChannelFuture</code> 添加回调</li>
                            <li>处理操作完成后的结果</li>
                        </ol>
                    </div>
                </div>
            </div>
        </section>

        <!-- Performance Optimization -->
        <section id="features" class="mb-20">
            <div class="flex items-center mb-8">
                <div class="w-2 h-10 bg-indigo-600 mr-4 rounded-full"></div>
                <h2 class="text-3xl font-bold">9. 高性能优化与扩展</h2>
            </div>
            
            <div class="bg-white rounded-xl shadow-md overflow-hidden hover-scale">
                <div class="p-8">
                    <p class="text-gray-700 mb-6">
                        Netty 为了提高性能，在架构设计上进行了多方面的优化，包括内存管理、线程模型和IO处理等多个层面。
                    </p>
                    
                    <div class="grid md:grid-cols-3 gap-6">
                        <div class="bg-gray-50 p-6 rounded-lg">
                            <div class="text-indigo-600 text-3xl mb-3">
                                <i class="fas fa-copy"></i>
                            </div>
                            <h4 class="font-bold text-lg mb-2">零拷贝 (Zero-copy)</h4>
                            <p class="text-gray-700 text-sm">
                                通过 DirectByteBuf 实现零拷贝数据传输，减少数据在 JVM 堆和操作系统内存之间的复制开销。
                            </p>
                        </div>
                        <div class="bg-gray-50 p-6 rounded-lg">
                            <div class="text-indigo-600 text-3xl mb-3">
                                <i class="fas fa-memory"></i>
                            </div>
                            <h4 class="font-bold text-lg mb-2">内存池 (Memory Pool)</h4>
                            <p class="text-gray-700 text-sm">
                                使用内存池化技术来管理 ByteBuf 的分配和回收，避免频繁的内存分配和垃圾回收。
                            </p>
                        </div>
                        <div class="bg-gray-50 p-6 rounded-lg">
                            <div class="text-indigo-600 text-3xl mb-3">
                                <i class="fas fa-users"></i>
                            </div>
                            <h4 class="font-bold text-lg mb-2">多线程处理</h4>
                            <p class="text-gray-700 text-sm">
                                使用多线程模型来提高并发能力，EventLoopGroup 通过多个线程来处理不同的连接。
                            </p>
                        </div>
                    </div>
                </div>
                <div class="bg-gray-100 px-8 py-6">
                    <h4 class="font-bold text-gray-800 mb-3 flex items-center">
                        <i class="fas fa-project-diagram mr-2 text-indigo-600"></i>执行流程
                    </h4>
                    <ol class="list-decimal pl-5 space-y-2 text-gray-700">
                        <li>在传输数据时，Netty 使用零拷贝技术避免了数据的多次复制</li>
                        <li>内存池和 ByteBuf 的高效管理减少了内存分配和回收的开销</li>
                        <li>优化的线程模型充分利用多核CPU的处理能力</li>
                        <li>最终实现高性能的网络通信</li>
                    </ol>
                </div>
            </div>
        </section>

        <!-- Summary -->
        <section class="mb-20">
            <div class="bg-gradient-to-r from-indigo-500 to-purple-600 rounded-xl p-8 text-white hover-scale">
                <h3 class="text-2xl font-bold mb-4">Netty 架构总结</h3>
                <p class="mb-6 opacity-90">
                    Netty 通过精巧的架构设计，实现了高性能、高并发的网络通信能力。其核心在于事件驱动模型、高效的线程管理、灵活的数据处理管道和优化的内存管理。这些特性使 Netty 成为构建高性能网络应用的理想选择。
                </p>
                <div class="grid md:grid-cols-2 lg:grid-cols-4 gap-4">
                    <div class="bg-white bg-opacity-20 p-4 rounded-lg backdrop-blur-sm">
                        <div class="text-2xl mb-2"><i class="fas fa-bolt"></i></div>
                        <h4 class="font-bold">高性能</h4>
                        <p class="text-xs opacity-90">优化的IO和线程模型</p>
                    </div>
                    <div class="bg-white bg-opacity-20 p-4 rounded-lg backdrop-blur-sm">
                        <div class="text-2xl mb-2"><i class="fas fa-expand"></i></div>
                        <h4 class="font-bold">高扩展</h4>
                        <p class="text-xs opacity-90">灵活的组件设计</p>
                    </div>
                    <div class="bg-white bg-opacity-20 p-4 rounded-lg backdrop-blur-sm">
                        <div class="text-2xl mb-2"><i class="fas fa-shield-alt"></i></div>
                        <h4 class="font-bold">稳定</h4>
                        <p class="text-xs opacity-90">成熟的社区和生态</p>
                    </div>
                    <div class="bg-white bg-opacity-20 p-4 rounded-lg backdrop-blur-sm">
                        <div class="text-2xl mb-2"><i class="fas fa-puzzle-piece"></i></div>
                        <h4 class="font-bold">灵活</h4>
                        <p class="text-xs opacity-90">支持多种协议和扩展</p>
                    </div>
                </div>
            </div>
        </section>
    </div>

    <!-- Footer -->
    <footer class="bg-gray-900 text-gray-300 py-12 px-4">
        <div class="container mx-auto max-w-6xl">
            <div class="flex flex-col md:flex-row justify-between items-center">
                <div class="mb-4 md:mb-0">
                    <h3 class="text-xl font-bold text-white mb-2">技术小馆</h3>
                    <p class="text-sm">探索技术奥秘，分享知识精华</p>
                </div>
                <div>
                    <a href="http://www.yuque.com/jtostring" class="text-indigo-400 hover:text-indigo-300 transition duration-300 flex items-center">
                        <i class="fas fa-external-link-alt mr-2"></i>
                        <span>访问语雀: www.yuque.com/jtostring</span>
                    </a>
                </div>
            </div>
            <div class="border-t border-gray-800 mt-8 pt-8 text-center text-sm text-gray-500">
                &copy; 2023 技术小馆. 保留所有权利.
            </div>
        </div>
    </footer>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            fontFamily: "'Noto Sans SC', sans-serif",
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
        
        // 简单的滚动动画
        document.querySelectorAll('a[href^="#"]').forEach(anchor => {
            anchor.addEventListener('click', function (e) {
                e.preventDefault();
                document.querySelector(this.getAttribute('href')).scrollIntoView({
                    behavior: 'smooth'
                });
            });
        });
    </script>
</body>
</html>
```